
// 备忘录模式：

// 在不破坏封装的前提下捕获一个对象的内部状态，并在该对象之外保存这个状态，
// 这样可以在以后将对象恢复到原先保存的状态。

#include <iostream>
#include <string>
using namespace std;

// 前向声明
class Memento;

// 原发器  典型实现
class Originator
{
public:
	Originator(){
		state = "";
	}
	Originator(string iState){
		state = iState;
	}
	// 创建备忘录对象
	Memento* createMemento();
	// 利用备忘录对象恢复原发器状态
	void restoreMemento(Memento* m);
	void setState(string iState){
		state = iState;
	}
	string getState(){
		return state;
	}
    void PrintState() {
        cout << state << "...Originator" << endl;
    }
private:
	string state;
};

// 备忘录  典型实现（仿照原生器的设计）
class Memento
{
public:
	Memento(){
		state = "";
	}
	Memento(Originator* o){
		state = o->getState();
	}
	void setState(string iState){
		state = iState;
	}
	string getState(){
		return state;
	}
    void PrintState() {
        cout << state << "...Memento" << endl;
    }
private:
	string state;
};

// 创建备忘录对象
Memento* Originator::createMemento(){
	return new Memento(this);
};
// 利用备忘录对象恢复原发器状态
void Originator::restoreMemento(Memento* m){
	state = m->getState();
};


// 负责人  典型实现
class Caretaker
{
public:
	Caretaker(){}
	Memento* getMemento(){
		return memento;
	}
	void setMemento(Memento *m){
		memento = m;
	}
private:
	Memento* memento;
};

// 客户端 示例代码
int main()
{
	// 创建原发器对象
	Originator* o = new Originator("step1");

	// 创建负责人对象
	Caretaker *c = new Caretaker();
	
	Memento* m1 = o->createMemento();
	c->setMemento(m1);
    o->PrintState();
	m1->PrintState();
	
	o->setState("step2");
	Memento* m2 = o->createMemento();
	c->setMemento(m2);
    o->PrintState();
	m2->PrintState();
	
	o->setState("step3");
	Memento* m3 = o->createMemento();
	c->setMemento(m3);
    o->PrintState();
	m3->PrintState();
	
	o->setState("step4");
	Memento* m4 = o->createMemento();
	c->setMemento(m4);
    o->PrintState();
	m4->PrintState();


    cout << "........ restore ......" << endl;
	// 从负责人对象中取出备忘录对象，实现撤销
	o->restoreMemento(m2);
    o->PrintState();
	
	m1->PrintState();
	m2->PrintState();
	m3->PrintState();
	m4->PrintState();

	return 0;
}
